var QC = function（）{
    var EMPTY_FUN = function（）{
    };
    var ieVer = window.ActiveXObject && ~~ navigator.userAgent.match（/ MSIE \ s +（\ d +）/）[1];
    var $ Toolkit = function（）{
        var str2dom =函数（_str）{
            var _ret = []，_ cot = arguments.callee._temp = arguments.callee._temp || document.createElement（“ div”）;
            ; _cot.innerHTML = _str;
            而（_cot.firstChild）{
                _ret.push（_cot.removeChild（_cot.firstChild））;
            }
            返回_ret.length> 1吗？函数（）{
                var tmp = document.createDocumentFragment（）;
                for（var i = 0; i <_ret.length; i ++）{
                    tmp.appendChild（_ret [i]）;
                }
                返回tmp;
            }（）：_ ret [0];
        };
        var format = function（str，obj）{
            返回str.replace（arguments.callee._reg，函数（_i，_1）{
                返回obj [_1]！== null吗？obj [_1]：_1;
            }）;
        }
        格式。_reg= / \ {（\ w +）\} / g;
        返回{
            str2dom：str2dom，格式：格式，扩展：函数（_Cld，_Prt）{
                var fn = EMPTY_FUN;
                fn.prototype = _Prt.prototype;
                _Cld.prototype = new fn（）;
                _Cld.constructor = _Cld;
                返回_Cld;
            }
        }
    }（）;
    var $ JSON = function（）{
        变种
            逃避= / [\\\“ \ x00- \ x1f \ x7f- \ x9f \ u00ad \ u0600- \ u0604 \ u070f \ u17b4 \ u17b5 \ u200c- \ u200f \ u2028- \ u202f \ u2060- \ u206f \ ufeff \ ufff0 -\ uffff] / g，
            meta = {'\ b'：'\\ b'，'\ t'：'\\ t'，'\ n'：'\\ n'，'\ f'：'\\ f'，'\ r '：'\\ r'，'“'：'\\”'，'\\'：'\\\\'};

        函数quote（string）{
            escapable.lastIndex = 0;
            返回escapable.test（string）吗？'“'+ string.replace（可转义，函数（a）{
                var c = meta [a];
                返回typeof c ==='字符串'吗？c：'\\ u'+（'0000'+ a.charCodeAt（0）.toString（16））。slice（-4）;
            }）+'“'：'”'+字符串+'“';
        }

        函数stringify（obj）{
            var ret = []，v =“”;
            对于（var i in obj）{
                v = obj [i];
                v = v！==未定义？v：“”;
                开关（typeof v）{
                    case'string'：
                        v =报价（v）;
                        打破;
                    case'object'：
                        v = stringify（v）;
                        打破;
                    案例'功能'：
                        继续;
                }
                ret.push（'“'+ i +'”：'+ v）;
            }
            返回'{'+ ret +'}';
        }

        返回{
            stringify：函数（）{
                返回window.JSON && JSON.stringify吗？JSON.stringify：字符串化
            }（），解析：函数（str）{
                str = str || “ {}”；
                var ret = {};
                尝试{
                    ret =（new Function（“ return（” + str +“）”））（）;
                }抓住（e）{
                    $ Console.error（“ JSON.parse => parse数据格式错误：” + str）;
                }
                返回ret
            }
        }
    }（）;
    var $ XML = function（）{
        如果（document.implementation.hasFeature（“ XPath”，“ 3.0”））{
            XMLDocument.prototype.selectNodes =函数（cXPathString，xNode）{
                如果（！xNode）{
                    xNode = this;
                }
                var oNSResolver = this.createNSResolver（this.documentElement）
                var aItems = this.evaluate（cXPathString，xNode，oNSResolver，XPathResult.ORDERED_NODE_SNAPSHOT_TYPE，null）
                var aResult = [];
                for（var i = 0; i <aItems.snapshotLength; i ++）{
                    aResult [i] = aItems.snapshotItem（i）;
                }
                返回结果；
            }
            Element.prototype.selectNodes =函数（cXPathString）{
                如果（this.ownerDocument.selectNodes）{
                    返回this.ownerDocument.selectNodes（cXPathString，this）;
                }
                其他{
                    抛出“仅用于XML元素”；
                }
            }
        }
        var loadXML = function（xmlString）{
            var XMLDoc = ieVer吗？新的ActiveXObject（“ Microsoft.XMLDOM”）：document.implementation.createDocument（“ text / xml”，“”，null）;
            如果（ieVer）{
                如果（XMLDoc.loadXML（xmlString））{
                    返回XMLDoc;
                }其他{
                    返回null;
                }
            }其他{
                尝试{
                    var childNodes = XMLDoc.childNodes;
                    对于（var i = childNodes.length-1; i> = 0; i--）
                        XMLDoc.removeChild（childNodes [i]）;
                    var dp = new DOMParser（）;
                    var newDOM = dp.parseFromString（xmlString，“ text / xml”）;
                    var newElt = XMLDoc.importNode（newDOM.documentElement，true）;
                    XMLDoc.appendChild（newElt）;
                    返回XMLDoc;
                }
                赶上（例如）{
                    返回null;
                }
            }
        }
        返回{
            stringify：函数（doc）{
                返回doc.xml || 新的XMLSerializer（）。serializeToString（doc）;
            }，解析：loadXML
        }
    }（）;
    var $ Object = function（）{
        返回{
            扩展：功能（）{
                var args = arguments，len = arguments.length，deep = false，i = 1，target = args [0]，opts，src，clone，
                    复制;
                if（typeof target ===“ boolean”）{
                    深=目标；
                    目标=参数[1] || {};
                    我= 2;
                }
                if（typeof target！==“ object” && typeof target！==“ function”）{
                    target = {};
                }
                如果（len === i）{
                    target = {};
                    - 一世;
                }
                为（; i <len; i ++）{
                    if（（opts = arguments [i]）！= null）{
                        对于（在opts中的变量名）{
                            src = target [name];
                            复制= opts [名称];
                            如果（目标===复制）{
                                继续;
                            }
                            if（deep && copy && typeof copy ===“ object” &&！copy.nodeType）{
                                如果（src）{
                                    clone = src;
                                } else if（复制instanceof Array）{
                                    clone = [];
                                } else if（typeof copy ==='object'）{
                                    clone = {};
                                }其他{
                                    复制=复制;
                                }
                                target [name] = object.extend（深层，克隆，复制）；
                            } else if（copy！== undefined）{
                                target [名称] =复制；
                            }
                        }
                    }
                }
                返回目标；
            }
        }
    }（）;
    var $ QueryString = function（）{
        var re = /“ / g;
        var工具= {
            genHttpParamString：函数（o）{
                返回this.commonDictionaryJoin（o，null，null，null，window.encodeURIComponent）;
            }，splitHttpParamString：函数（s）{
                返回this.commonDictionarySplit（s，null，null，null，window.decodeURIComponent）;
            }，commonDictionarySplit：函数（s，esp，vq，eq，valueHandler）{
                var res = {}，l，ks，vs，t，vv;
                if（！s || typeof（s）！=“ string”）{
                    返回资源；
                }
                如果（typeof（esp）！='字符串'）{
                    esp =“＆”;
                }
                如果（typeof（vq）！='字符串'）{
                    vq =“”;
                }
                如果（typeof（eq）！='字符串'）{
                    eq =“ =”;
                }
                l = s.split（esp）;
                如果（l && l.length）{
                    对于（var i = 0，len = l.length; i <len; ++ i）{
                        ks = l [i] .split（eq）;
                        如果（ks.length> 1）{
                            t = ks.slice（1）.join（eq）;
                            vs = t.split（vq）;
                            vv = vs.slice（vq.length，vs.length-vq.length）.join（vq）;
                            res [ks [0]] =（typeof valueHandler =='function'？valueHandler（vv）：vv）;
                        }其他{
                            ks [0] &&（res [ks [0]] = true）;
                        }
                    }
                }
                返回资源；
            }，commonDictionaryJoin：函数（o，esp，vq，eq，valueHandler）{
                var res = []，t，ok;
                if（！o || typeof（o）！=“对象”）{
                    返回'';
                }
                if（typeof（o）==“ string”）{
                    返回o
                }
                如果（typeof（esp）！='字符串'）{
                    esp =“＆”;
                }
                如果（typeof（vq）！='字符串'）{
                    vq =“”;
                }
                如果（typeof（eq）！='字符串'）{
                    eq =“ =”;
                }
                对于（var k in o）{
                    ok =（o [k] +“”）.replace（re，“ \\\”“）;
                    res.push（k + eq + vq +（typeof valueHandler =='function'？valueHandler（ok）：ok）+ vq）;
                }
                返回res.join（esp）;
            }
        }
        返回{
            stringify：函数（obj）{
                返回tool.genHttpParamString（obj）;
            }，解析：函数（str）{
                返回tool.splitHttpParamString（str）;
            }，getParameter：函数（名称）{
                var r = new RegExp（“（\\？|＃|＆）” +名称+“ =（[[^＆＃] *）（＆|＃| $）”），m = location.href.match（r） ;
                返回decodeURIComponent（！m？“”：m [2]）;
            }
        }
    }（）;
    var $ String = function（）{
        var res = [/＆（?! amp; | lt; | gt; |＃039; |“ |＃39;）/ g，/ </ g，/> / g，/ \ x27 / g，/ \ x22 / g]，
            rep = ['＆amp;'，'＆lt;'，'＆gt;'，'＆＃039;'，'＆quot;']];
        返回{
            escHTML：函数（str）{
                var ret = str;
                for（var i = 0，l = res.length; i <l; i ++）{
                    ret = ret.replace（res [i]，rep [i]）;
                }
                返回ret
            }，格式：$ Toolkit.format
        }
    }（）;
    var $ Cookie = function（）{
        var domainPrefix = document.domain || “”;
        返回{
            设置：函数（名称，值，域，路径，小时）{
                如果（小时）{
                    var expire = new Date（）;
                    expire.setTime（expire.getTime（）+ 3600000 *小时）;
                }
                document.cookie =名称+“ =” +值+“;” +（小时？（“ expires =” + expire.toGMTString（）+“;”）：“”）+（路径？（“ path =” +路径+“;”）：“ path = /;”）+（domain？（“ domain =” + domain +“;”）：（“ domain =” + domainPrefix +“;”））;;
                返回true；
            }，获取：函数（名称）{
                var r = new RegExp（“（？：^ |; + | \\ s +）” +名称+“ =（[^;] *）”），m = document.cookie.match（r）;
                return（！m？“”：m [1]）;
            }，del：函数（名称，域，路径）{
                document.cookie = name +“ =; expires = Mon，26 Jul 1997 05:00:00 GMT;” +（path？（“ path =” + path +“;”）：“ path = /;”）+（ domain？（“ domain =” + domain +“;”）：（“ domain =” + domainPrefix +“;”）））;
            }
        }
    }（）;
    var $ Console = function（）{
        var LEVELS = {日志：3，信息：2，警告：1，错误：0}；
        var _QC_CONSOLE_DEBUG_LEVEL = LEVELS.info;
        var cons_prefix =':: [QQConnect]>';
        var trace = function（funName）{
            返回函数（参数）{
                window.console && console [funName] && getDebugLevel（）> = LEVELS [funName] && console [funName]（cons_prefix + args）;
            }
        };
        var getDebugLevel = function（）{
            返回~~（_QC_CONSOLE_DEBUG_LEVEL || LEVELS.info）;
        };
        返回{
            日志：trace（“ log”），
            信息：trace（“ info”），
            警告：trace（“ warn”），
            错误：trace（“错误”），
            setLevel：函数（lvNm）{
                返回_QC_CONSOLE_DEBUG_LEVEL = LEVELS [lvNm] || _QC_CONSOLE_DEBUG_LEVEL;
            }
        }
    }（）;
    var $ Event = function（）{
        var readyBound;

        函数ready（）{
            ready.fired = true;
            var fun;
            while（fun = ready.list.shift（））{
                fun（）;
            }
        }

        ready.list = [];
        ready.fired = false;

        函数bindReady（）{
            如果（readyBound）返回；
            readyBound = true;
            如果（document.addEventListener）{
                document.addEventListener（“ DOMContentLoaded”，function（）{
                    document.removeEventListener（“ DOMContentLoaded”，arguments.callee，false）;
                    准备（）;
                }，错误）；
            }否则，如果（document.attachEvent）{
                document.attachEvent（“ onreadystatechange”，function（）{
                    如果（document.readyState ===“完成” || document.readyState ===“已加载”）{
                        document.detachEvent（“ onreadystatechange”，arguments.callee）;
                        准备（）;
                    }
                }）;
                如果（document.documentElement.doScroll）{
                    （函数（）{
                        尝试{
                            document.documentElement.doScroll（“ left”）;
                            document.body.appendChild;
                        } catch（错误）{
                            如果（！ready.fired）{
                                setTimeout（arguments.callee，0）;
                            }
                            返回;
                        }
                        准备（）;
                    }）（）;
                }
            }
        }

        bindReady（）;
        返回{
            domReady：函数（有趣）{
                如果（（typeof（fun）==“ function”））{
                    如果（ready.fired || document.readyState ===“完成” || document.readyState ===“已加载”）{
                        准备（）;
                        fun（）;
                    }其他{
                        ready.list.push（有趣）;
                    }
                }
            }，添加：函数（dom，evtTp，fn）{
                如果（dom && evtTp && fn）{
                    dom && dom.addEventListener？dom.addEventListener（evtTp，fn，false）：dom.attachEvent（“ on” + evtTp，fn）;
                }
            }，删除：function（dom，evtTp，fn）{
                如果（dom && evtTp && fn）{
                    dom && dom.removeEventListener？dom.removeEventListener（evtTp，fn，false）：dom.detachEvent（“ on” + evtTp，fn）;
                }
            }
        }
    }（）;
    var Like = function（）{
        返回{_insertButton：EMPTY_FUN}
    };
    var Share = function（）{
        返回{}
    };
    var _pv =函数（域，路径，选择）{
        setTimeout（function（）{
            _pv.send（domain，path，opts）;
        }，0）;
    }
    _pv.send =函数（域，路径，opts）{
        var pvCgi =“ https://pingfore.qq.com/pingd”;
        var sParam =“？cc =-＆ct =-＆java = 1＆lang =-＆pf =-＆scl =-＆scr =-＆tt =-＆tz = -8＆vs = 3.3＆flash =＆”;
        var _cookieP = /（？：^ |; + | \ s +）pgv_pvid =（[[^;] *）/ i;
        var ref，dm，url，rdm，rurl，pgv_pvid，sds，t，img；
        opts = opts || {};
        dm =域|| location.hostname || “-”;
        url =路径|| “ /打开/连接/ error_path”;
        rdm = opts.referDomain || location.hostname;
        rurl = opts.referPath || location.pathname;
        sds = Math.random（）;
        t = document.cookie.match（_cookieP）;
        如果（t && t.length && t.length> 1）{
            pgv_pvid = t [1];
        }其他{
            pgv_pvid =（Math.round（Math.random（）* 2147483647）*（新的Date（）。getUTCMilliseconds（）））％10000000000;
            document.cookie =“ pgv_pvid =” + pgv_pvid +“; path = /; domain =” + location.hostname +“; expires = Sun，2038年1月18日格林尼治标准时间00:00:00 GMT;”;
        }
        img = new Image（）;
        img.onload = img.onerror = function（）{
            img.onload = img.onerror = null;
            img = null;
        };
        img.src = pvCgi + sParam +“ dm =” + dm +“＆url =” + url +“＆rdm =” + rdm +“＆rurl =” + escape（rurl）+“＆pgv_pvid =” + pgv_pvid +“＆sds =” + sds;
    };
    var _valueStat =函数（statId，resultType，returnValue，opts）{
        setTimeout（function（）{
            _valueStat.send（statId，resultType，returnValue，opts）;
        }，0）;
    }
    _valueStat.send =函数（statId，resultType，returnValue，opts）{
        var vsCgi =“ https://isdspeed.qq.com/cgi-bin/v.cgi"，params，img；
        opts = opts || {};
        params = [“ flag1 =” + statId，“ flag2 =” + resultType，“ flag3 =” + returnValue，“ 1 =” +（opts.reportRate || 1），“ 2 =” +（opts.duration || 1000 ），“ sds =” + Math.random（）];
        img = new Image（）;
        img.onload = img.onerror = function（）{
            img.onload = img.onerror = null;
            img = null;
        };
        img.src = vsCgi +“？” + params.join（“＆”）;
    };
    var reportBNL =函数（id，obj）{
        var timestamp = + new Date（）;
        var img = document.createElement（'img'）;
        obj = obj || 0;
        img.src ='https://cgi.connect.qq.com/report/report?strValue='+ obj +'＆nValue ='+ id +'＆tag = 0＆t ='+时间戳；
    }
    返回{
        像：像（），
        分享：Share（），
        工具包：$ Toolkit，
        JSON：$ JSON，
        XML：$ XML，
        对象：$ Object，
        QueryString：$ QueryString，
        字串：$ String，
        Cookie：$ Cookie，
        控制台：$ Console，
        事件：$ Event，
        pv：_pv，
        valueStat：_valueStat，
        reportBNL：reportBNL，
        getVersion：function（）{
            返回“ 1.0.1”；
        }
    }
}（）;
（函数（_qc）{
    var _ver = QC.getVersion（）;
    var $ =函数（_）{
        返回typeof（_）==“ string”吗？document.getElementById（_）：_
    };
    var resDomain =“ qzonestyle.gtimg.cn”，mainDomain =“ qzs.qq.com”;
    var qc_script;
    var getDataPara = function（para）{
        返回qc_script &&（qc_script.dataset && qc_script.dataset [para] || qc_script.getAttribute（“ data-” + para）））;
    };
    var __qc_wId;
    ！（函数（）{
        __qc_wId = ~~ _qc.QueryString.getParameter（“ __ qc_wId”）|| ~~ _qc.Cookie.get（“ __ qc_wId”）;
        如果（！__ qc_wId）{
            var ret = + new Date（）％1000;
            document.cookie = [“ __qc_wId =” + ret，“; path = /”]。join（“;”）;
        }
    }）（）;
    // var reg = /\/qzone\/openapi\/qc(?:[^/_]*)\.js(?:[?#]appId=(\d+))?/i;
    var reg = / qc_jssdk / i;
    var脚本= document.getElementsByTagName（“ script”）;
    for（var i = 0，script，l = scripts.length; i <l; i ++）{
        脚本=脚本[i];
        var src = script.src || “”;
        var mat = src.match（reg）;
        如果（mat）{
            qc_script =脚本；
            打破;
        }
    }

    var $ Toolkit = _qc.Toolkit，$ JSON = _qc.JSON，$ XML = _qc.XML，$ Object = _qc.Object，$ QueryString = _qc.QueryString，
        $ String = _qc.String，$ Cookie = _qc.Cookie，$ Console = _qc.Console;
    var EMPTY_FUN = function（）{};
    var ieVer = window.ActiveXObject && ~~ navigator.userAgent.match（/ MSIE \ s +（\ d +）/）[1];
    var config = {
        PMCrossPage：“ https://graph.qq.com/jsdkproxy/PMProxy.html#” + _ver，
        FLACrossPage：“ https://graph.qq.com/jsdkproxy/FLAProxy.swf”，
        getCrossSolution：函数（）{
            var解;
            如果（window.postMessage）{
                解决方案=“ PMProxy”;
            } else if（!!（（window.ActiveXObject && !! function（）{
                var ret = true;
                尝试{
                    新的ActiveXObject（'ShockwaveFlash.ShockwaveFlash'）
                }抓住（e）{
                    ret = false;
                }
                返回ret
            }（））|| （navigator.plugins && navigator.plugins [“ Shockwave Flash”]）|| 假））{
                解决方案=“ FLAProxy”;
            }其他{
                _qc.Console.error（“未找到可用的跨域通信方案”）;
                解决方案=“ EMPProxy”;
            }
            _qc.Console.info（“确定跨域代理策略：” +解决方案）;
            返回解决方案；
        }
    };
    var sequence = 1000;
    _qc.getConfig = function（）{
        返回配置;
    };
    var Request =函数（uri，paras，fmt，方法）{
        this.uri = uri;
        this.paras = paras || {};
        this.fmt = fmt || “ json”;
        this.method =（method ||“ get”）。toLocaleLowerCase（）;
        this.successPool = [];
        this.errorPool = [];
        this.completePool = [];
        this.seq = sequence ++;
    };
    Request.prototype.success =函数（有趣）{
        this.successPool.push（fun）;
        返回这个
    };
    Request.prototype.error =函数（有趣）{
        this.errorPool.push（fun）;
        返回这个
    };
    Request.prototype.complete =函数（有趣）{
        this.completePool.push（fun）;
        返回这个
    };
    Request.prototype.send = EMPTY_FUN;
    Request.prototype._onCallback =函数（xhr，fmt，seq）{
        如果（xhr.status == 200 || xhr.status == 204）{
            var responseText = xhr.responseText，response =新的Response（responseText，xhr.status，fmt，seq）;
            ！~~ response.code？this.onSuccess（response）：this.onError（response）;
        }其他{
            this.onError（new Response（“”，xhr.status，fmt，seq））;
        }
    };
    Request.prototype.onSuccess =函数（响应）{
        var pool = this.successPool;
        for（var i = 0; i <pool.length; i ++）{
            池[i]（响应）；
        }
        this.onComplete（response）;
    };
    Request.prototype.onError =函数（响应）{
        var pool = this.errorPool;
        for（var i = 0; i <pool.length; i ++）{
            池[i]（响应）；
        }
        this.onComplete（response）;
    };
    Request.prototype.onComplete =函数（响应）{
        var pool = this.completePool;
        for（var i = 0; i <pool.length; i ++）{
            池[i]（响应）；
        }
    };
    var Response =函数（respData，状态，fmt，seq）{
        this.status =状态|| -1;
        this.fmt = fmt || “ json”;
        this.code = this.ret = -1;
        this.data = null;
        this.seq = seq || -1;
        this.parseData（respData）;
        如果（this.code && Response [this.code]）{
            响应[this.code]（this.data，this.dataText）；
        }
    };
    Response.prototype.parseData =函数（rd）{
        this.dataText = rd;
        切换（this.fmt）{
            案例“ xml”：
                this.data = _qc.XML.parse（rd ||'<root> </ root>'）;
                var node = this.data.selectNodes（“ // ret”）[0];
                this.code = this.ret =（节点&& node.firstChild.nodeValue）|| -1;
                打破;
            case“ json”：
            默认：
                this.data = _qc.JSON.parse（rd ||'{}'）;
                this.code = this.ret = this.data.ret！==未定义？~~ this.data.ret：this.data.data && this.data.data.ret！==未定义？~~ this.data.data.ret：-1;
                打破;
        }
    };
    Response.prototype.stringifyData = function（）{
        返回this.dataText;
    };
    响应[100013] =函数（dt，dtTxt）{
        _qc.Login.signOut（）;
        _qc.Console.warn（“ api返回令牌无效”）;
    };
    var XHRRequest = _qc.Toolkit.extend（function（）{
        Request.apply（this，arguments）;
        this.xhr = XHRRequest.createInstance（）;
    }，Request）;
    _qc.Object.extend（XHRRequest.prototype，{
        发送：function（）{
            var xhr = this.xhr，方法= this.method，fmt = this.fmt，me = this，
                paras = _qc.QueryString.stringify（me.paras），
                uri =方法==“发布”？this.uri：this.uri.indexOf（“？”）<0吗？this.uri +'？' + paras：this.uri.replace（/ [＆？] * / g，“”）+'＆'+ paras;
            xhr.open（方法，uri，!! this.async）;
            尝试{
                xhr.setRequestHeader（“ Content-Type”，“ application / x-www-form-urlencoded”）;
                xhr.setRequestHeader（“ X-Requested-From”，“ _TC_QC_jsProxy_”）;
            }抓住（e）{
            }
            xhr.onreadystatechange = function（）{
                如果（xhr.readyState === 4）{
                    me._onCallback（xhr，fmt，me.seq）;
                }
            };
            xhr.send（paras || null）;
        }
    }）;
    XHRRequest.createInstance = window.XMLHttpRequest吗？函数（）{
        返回新窗口。XMLHttpRequest（）;
    }：函数（）{
        返回新窗口。ActiveXObject（“ Microsoft.XMLHTTP”）;
    };
    var Proxy = function（）{
        this.requests = [];
        this.invokes = [];
        this.readyPool = [];
        this.isReady = false;
        this.timeStamp = + new Date（）;
        this.init（）;
    };
    Proxy.prototype.init = EMPTY_FUN;
    Proxy.prototype.ready =函数（有趣）{
        this.readyPool.push（fun）;
    };
    Proxy.prototype.onReady = function（）{
        this.isReady = true;
        var pool = this.readyPool;
        for（var i = 0; i <pool.length; i ++）{
            池[i]（）;
        }
    };
    Proxy.prototype.send =函数（要求）{
        varendingRequest;
        req &&（this.requests.push（req））;
        while（this.isReady &&（pendingRequest = this.requests.shift（）））{
            Proxy.pendingRequests.push（pendingRequest）;
            QC.Console.log（“ seq no：” + endingRequest.seq +“请求发起” +“ ts->” +（+ new Date（）））;
            this._doSend（pendingRequest）;
        }
    };
    Proxy.prototype._doSend =函数（要求）{
    };
    Proxy.prototype._preDispatch =函数（_this，cstDt，seq，fmt）{
        var dt = cstDt.data || （cstDt.currentTarget && cstDt.currentTarget.data）|| {};
        var cmd = dt.split（“ @@@”）;
        开关（cmd [0]）{
            案例“调用”：
                this.invoke（cmd [1]）;
                打破;
            默认：
                this.dispatch（cmd [1] || cstDt，seq，fmt）;
                打破;
        }
    };
    Proxy.prototype.invoke =函数（ivk）{
        varendingInvoke;
        ivk &&（this.invokes.push（ivk））;
        while（this.isReady &&（pendingInvoke = this.invokes.shift（）））{
            this._doInvoke（pendingInvoke）;
        }
    };
    Proxy.prototype._doInvoke =函数（ivk）{
    };
    Proxy.prototype.dispose = function（）{
        _proxy = null;
        this.onDispose（）;
    };
    Proxy.prototype.onDispose = function（）{
    };
    Proxy.pendingRequests = [];
    Proxy.dispatchReceive =函数（seq，resText，状态，fmt）{
        varendingRequests = Proxy.pendingRequests;
        对于（var i = 0; i <endingRequests.length; i ++）{
            如果（pendingRequests [i] .seq == seq）{
                QC.Console.log（“ seq no：” + seq +“响应收到” +“ ts->” +（+ new Date（）））;
                endingRequests [i] ._ onCallback（{status：status，responseText：resText}，fmt，seq）;
                endingRequests.splice（i，1）;
                返回;
            }
        }
    };
    Proxy.invoke =函数（）{
        var _pendingPool = [];
        返回函数（cmdStr）{
            cmdStr && _pendingPool.push（cmdStr）;
            如果（！_proxy）{
                _qc.Console.info（“ Proxy未初始化，invoke入栈”）;
                Proxy.generateProxy（）;
                返回;
            }
            var _crtIvk;
            而（_crtIvk = _pendingPool.shift（））{
                _proxy._doInvoke（_crtIvk）;
            }
        }
    }（）;
    var _proxy;
    Proxy.generateProxy =函数（_name）{
        var _solutions = {PMProxy：PMProxy，FLAProxy：FLAProxy，EMPProxy：EMPProxy}；
        如果（_name）{
            返回新的_solutions [_name]（）;
        }
        如果（！_proxy）{
            _proxy =新的_solutions [config.getCrossSolution（）]（）;
        }
        返回_proxy;
    };
    Proxy.getFunction =函数（cmdP）{
        var cmd;
        cmdP = cmdP.split（“。”）;
        对于（var i = 0; i <cmdP.length; i ++）{
            cmd = cmd吗？cmd [cmdP [i]]：窗口[cmdP [i]]；
        }
        返回cmd;
    };
    _qc._create_fla_proxy =函数（）{
        _qc._create_fla_proxy = EMPTY_FUN;
        如果（！（document ['_ qc_cross_request_flash_proxy'] || $（'_ qc_cross_request_flash_proxy'）））{
            新的FLAProxy（）;
        }
    };
    var FLAProxy = _qc.Toolkit.extend（function（）{
        Proxy.apply（this，arguments）;
    }， 代理）;
    _qc.Object.extend（FLAProxy.prototype，{
        前缀：“ _ TC_QC_flaProxy_”，初始化：function（）{
            var _me = this，conId = function（）{
                var mat = window.name.match（/ oauth2Login _（\ d +）/），__qc_wId = ~~ _qc.Cookie.get（“ __ qc_wId”），ret;
                如果（mat && mat [1]）{
                    ret = mat [1];
                }否则，如果（window._b_is_qc_cb_win）{
                    ret = 10000 + __qc_wId;
                }其他{
                    ret = __qc_wId;
                    document.cookie = [“ __qc_wId =” + ret，“; path = /”]。join（“;”）;
                }
                _qc.Console.info（“跨域窗口标识号__qc_wId：” + ret）;
                返回ret
            }（），receiveId = conId <10000吗？conId + 10000：conId-10000;
            var flaStr = FLAProxy.getFlashHtml（{
                “ src”：config.FLACrossPage，
                “ width”：“ 100％”，
                “高度”：“ 100％”，
                “ allowScriptAccess”：“始终”，
                “ id”：“ _qc_cross_request_flash_proxy”，
                “ name”：“ _qc_cross_request_flash_proxy”，
                “ flashVars”：“后缀=” +（this.timeStamp）+“＆conId =” + conId +“＆conId_receive =” + receiveId
            }）;
            var cot = this.cot = document.createElement（“ div”）;
            cot.style.cssText =“ position：fixed; _position：absolute; top：-999px; left：-999px; width：1px; height：1px; margin：0; padding：0; display：none;”;
            cot.innerHTML = flaStr;
            QC.Event.domReady（function（）{
                document.body.appendChild（cot）;
                cot.style.display =“ block”;
            }）;
            窗口[this.prefix +'onFlashReady_'+ this.timeStamp] =函数（）{
                _qc.Console.info（“ FLAProxy代理创建成功，耗时” +（new Date（）-_me.timeStamp））；
                setTimeout（function（）{
                    _me.isReady = true;
                    _me.send（）;
                    _me.invoke（）;
                }）;
                如果（！_qc.Login._check（））{
                    document ['_ qc_cross_request_flash_proxy']。initConn（）;
                }
            };
            窗口[this.prefix +'onFlashRequestComplete_'+ this.timeStamp] =函数（cstDt，seq，fmt）{
                setTimeout（function（）{
                    _me._preDispatch（_me，cstDt，seq，fmt）;
                }）;
            };
            窗口[this.prefix +'onFlashInvokeBack_'+ this.timeStamp] =函数（）{
                var arg = arguments;
                setTimeout（function（）{
                    var fun = Proxy.getFunction（arg [0]）;
                    var paras = arg [1];
                    arg [0] .indexOf（“。”）> -1吗？fun.apply（null，paras）：fun（paras）;
                }）;
            };
        }，_ doSend：函数（regObj）{
            var uri = regObj.uri，paras = _qc.QueryString.stringify（regObj.paras），seq = regObj.seq，fmt = regObj.fmt，
                方法= regObj.method;
            var proxyFun = document ['_ qc_cross_request_flash_proxy']。httpRequest || $（'_ qc_cross_request_flash_proxy'）。httpRequest;
            proxyFun？proxyFun（uri，paras，method，fmt，seq）：（！function（）{
                抛出新的错误（“ Flash代理初始化失败”）
            }（））;
        }，调度：函数（cstDt，seq，fmt）{
            var data = cstDt.currentTarget.data，status = cstDt.type！=“完成”？404：200；
            Proxy.dispatchReceive（seq，data，status，fmt）;
        }，_doInvoke：函数（args）{
            var fun = document ['_ qc_cross_request_flash_proxy']。jsCallSwf || $（'_ qc_cross_request_flash_proxy'）。jsCallSwf;
            fun && fun.apply（null，args）;
        }
    }）;
    FLAProxy.getFlashHtml =函数（flashArguments，requiredVersion，flashPlayerCID）{
        var _attrs = []，_ params = []，_ isIE = !! window.ActiveXObject;
        requiredVersion = requiredVersion || 9;
        for（flashArguments中的var k）{
            开关（k）{
                案例“ noSrc”：
                案例“电影”：
                    继续;
                    打破;
                案例ID”：
                案例“名称”：
                情况“宽度”：
                案例“身高”：
                案例“风格”：
                    if（typeof（flashArguments [k]）！='undefined'）{
                        _attrs.push（''，k，'=“'，flashArguments [k]，'”'）;
                    }
                    打破;
                案例“ src”：
                    如果（_isIE）{
                        _params.push（'<param name =“ movie” value =“'，（flashArguments.noSrc？”“：flashArguments [k]），'” />'）;
                    }其他{
                        _attrs.push（'data =“'，（flashArguments.noSrc？”“：flashArguments [k]），'”'）;
                    }
                    打破;
                默认：
                    _params.push（'<param name =“'，k，'” value =“'，flashArguments [k]，'” />'）;
            }
        }
        如果（_isIE）{
            _attrs.push（'classid =“ clsid：'，flashPlayerCID ||'D27CDB6E-AE6D-11cf-96B8-444553540000'，'”'）;
        }其他{
            _attrs.push（'type =“ application / x-shockwave-flash”'）;
        }
        如果（location && location.protocol.indexOf（“ https”）<0）{
            _attrs.push（'codeBase =“ http://fpdownload.macromedia.com/get/flashplayer/current/swflash.cab#version='，requiredVersion，'”'）;
        }
        返回“ <object” + _attrs.join（“”）+“>” + _params.join（“”）+“ </ object>”;
    };
    var _origin =“ https://graph.qq.com”，_origin_static =“ https://qzonestyle.gtimg.cn”;
    var PMProxy = _qc.Toolkit.extend（function（）{
        Proxy.apply（this，arguments）;
    }， 代理）;
    _qc.Object.extend（PMProxy.prototype，{
        初始化：函数（）{
            var _me = this;
            _me._connFrame = document.createElement（“ iframe”）;
            _me._connFrame.style.cssText =“宽度：0px；高度：0px；显示：无；溢出：隐藏；”；
            var _frame_on_load = function（）{
                _frame_on_load.fire（）;
                _frame_on_load.fire = EMPTY_FUN;
            };
            _frame_on_load.fire =函数（）{
                _qc.Console.info（“ PMProxy代理创建成功，耗时” +（new Date（）-_me.timeStamp））；
                _me.isReady = true;
                _me.send（）;
                _me.invoke（）;
            };
            _me._connFrame.onload = _frame_on_load;
            _me._connFrame.addEventListener和＆_me._connFrame.addEventListener（“ load”，_frame_on_load，false）;
            _me._connFrame.attachEvent && _me._connFrame.attachEvent（“ onload”，_frame_on_load）;
            _me._connFrame.src = config.PMCrossPage;
            QC.Event.domReady（function（）{
                document.body.appendChild（_me._connFrame）;
            }）;
            var _preDispatchHandler =函数（crsDt）{
                如果（crsDt.origin &&（crsDt.origin == _origin || crsDt.origin == _origin_static））{
                    _me._preDispatch（_me，crsDt）;
                }
            };
            window.addEventListener吗？window.addEventListener（“ message”，_preDispatchHandler，false）：window.attachEvent（“ onmessage”，_preDispatchHandler）;
        }，_ doSend：函数（regObj）{
            var str = _qc.QueryString.stringify（{
                uri：regObj.uri，
                参数：_qc.QueryString.stringify（regObj.paras），
                fmt：regObj.fmt，
                方法：regObj.method
            }）;
            this._connFrame.contentWindow.postMessage（str，_origin）;
        }，dispatch：函数（crsDt）{
            var dt = crsDt.data，obj = dt.split（“：<。<<＃：”），seq = obj [0]，status = obj [1]，fmt = obj [2]，data = obj [3 ];
            _qc.Console.log（“ data：\ t” +数据）;
            Proxy.dispatchReceive（seq，data，status，fmt）;
        }，_doInvoke：函数（cmdStr）{
            _qc.Console.log（“ invoke：\ t” + cmdStr）;
            如果（typeof cmdStr！=“ string”）{
                返回;
            }
            var pas = cmdStr.split（“＃”），cmdP = pas [0]，args = pas [1] && pas [1] .split（“，”），cmd;
            cmd = Proxy.getFunction（cmdP）;
            cmd.apply（null，args）;
        }，onDispose：function（）{
            this._connFrame.parentNode.removeChild（this._connFrame）;
            this._connFrame = null;
        }
    }）;
    var EMPProxy = _qc.Toolkit.extend（function（）{
        Proxy.apply（this，arguments）;
    }， 代理）;
    _qc.Object.extend（EMPProxy.prototype，{
        初始化：函数（）{
            _qc.Console.info（“ init：” +参数）
        }，_ doSend：函数（regObj）{
            _qc.Console.info（“ _ doSend：” +参数）
        }，dispatch：函数（crsDt）{
            _qc.Console.info（“ dispatch：” +参数）
        }
    }）;
    _qc.XHRRequest = XHRRequest;
    _qc.request =函数（uri，paras，fmt，方法）{
        返回新的XHRRequest（uri，paras，fmt，method）;
    };
    var fun_ready_pool = [];
    _qc.api =函数（）{
        var _pendingPool = [];
        var bindTokenPara =函数（req）{
            var TKObj = _qc.Login._getTokenKeys（）;
            如果（appId <= 0）抛出新错误（“意外的调用了绑定令牌到req的方法bindTokenPara”）；
            req.paras.oauth_consumer_key = appId;
            req.paras.access_token = TKObj.accessToken;
            req.paras.openid = TKObj.openid;
            req.paras.format = req.fmt;
            返回要求
        };
        var fun =函数（api，paras，fmt，方法）{
            _proxy = Proxy.generateProxy（）;
            var defAPICfg = getAPIConfig（api）;
            api = defAPICfg.api || api;
            paras = paras || {};
            方法=方法|| defAPICfg.method;
            var req = new Request（api，paras，fmt，method）;
            如果（appId> 0）{
                setTimeout（function（）{
                    var aToken = _qc.Login._getTokenKeys（）;
                    如果（aToken.openid && aToken.accessToken）{
                        _proxy.send（bindTokenPara（req））;
                    }其他{
                        _pendingPool.push（req）;
                        _qc.Console.log（“ openid与accessToken丢失，调用请求入栈：[” + api +“]，栈大小：” + _pendingPool.length）;
                    }
                }，10）;
            }其他{
                _pendingPool.push（req）;
                _qc.Console.log（（_ proxy.isReady && appId <0？“令牌获取失败，请调用用户登录流程”：“ api代理尚未初始化成功”）+“，调用请求进入栈：[” + api +“] ，栈大小：“ + _pendingPool.length）;
            }
            req.success（function（）{
                QC.valueStat（defAPICfg.statId，1，0）;
            }）。error（function（response）{
                var resp =响应|| {};
                QC.valueStat（defAPICfg.statId，1，“ number” == typeof resp.ret？resp.ret：1）;
            }）;
            返回要求
        };
        fun._ready = function（）{
            _qc.Console.info（“ init成功，开始触发api调用样式”）;
            var _crtReq;
            而（_crtReq = _pendingPool.shift（））{
                _proxy.send（bindTokenPara（_crtReq））;
            }
        };
        fun.getDoc = function（）{
            var DOCS = null，loadDocJS = function（key，fun）{
                var script = document.createElement（“ script”）;
                script.type =“ text / javascript”;
                script.src =“ https://qzonestyle.gtimg.cn/qzone/openapi/qc_jsdkdoc.js”；
                document.body.appendChild（script）;
                window.on_qc_jsdkdoc_loaded =函数（_docs）{
                    DOCS = _docs;
                    fun && fun（DOCS [key]）;
                    document.body.removeChild（script）;
                    脚本= null;
                };
            };
            返回函数（键，有趣）{
                （DOCS &&乐趣）？fun（DOCS [key]）：loadDocJS（key，fun || EMPTY_FUN）;
            };
        }（）;
        回报乐趣；
    }（）;
    var Login = function（）{
        var _openId，access_token，dt_cache;
        var BUTTON_STYLE = {
            A_XL：{styleId：5，尺寸：'230 * 48'}，
            A_L：{styleId：4，大小：'170 * 32'}，
            A_M：{styleId：3，大小：'120 * 24'}，
            A_S：{styleId：2，size：'105 * 16'}，
            B_M：{styleId：7，尺寸：'63 * 24'}，
            B_S：{styleId：6，尺寸：'50 * 16'}，
            C_S：{styleId：1，大小：'16 * 16'}
        };

        //初始化登录按钮
        函数_insertButton（opts）{
            如果（opts.clientId）{
                QC.init（{appId：opts.clientId}）;
            }
            var appid = QC.getAppId（）;
            如果（appid <0）{
                QC.getAppId（arguments）;
                返回;
            }
            opts.size = opts ['size'] || 'B_M';
            var btn = $（opts ['btnId']），sizeObj = BUTTON_STYLE [opts ['size']] || BUTTON_STYLE ['B_M']，
                size = sizeObj ['styleId']，fullWindow = opts ['fullWindow'] || 假，
                btnMode = opts ['btnMode'] || '标准';
            opts.redirectURI = opts ['redirectURI'] || redirectURI;
            var url = arguments.callee._getPopupUrl（opts）;
            var parasObj = {size：size，fullWindow：fullWindow，url：url};
            如果（opts && opts ['btnId']）{
                如果（btn）{
                    btn.innerHTML = arguments.callee.getBtnHtml（parasObj，btnMode，opts）;
                    var onclick = btn.firstChild.onclick;
                    如果（！opts.showModal）{
                        （btn.firstChild.onclick =函数（_a）{
                            var crtPop，_close = function（）{
                                crtPop && crtPop.close（）;
                                QC.Cookie.del（“ __ qc_wId”）;
                            };
                            window.addEventListener吗？window.addEventListener（“ unload”，_close，false）：window.attachEvent（“ onunload”，_close）;
                            返回函数（）{
                                如果（crtPop）{
                                    crtPop.close（）;
                                }
                                crtPop = _a（）;
                                如果（！crtPop || true）{
                                    _qc._create_fla_proxy（）;
                                }
                                QC.pv（“ graph.qq.com”，“ / open / connect / click”）;
                                返回false；
                            }
                        }（onclick））；
                    }其他{
                        var modal = document.createElement（'DIV'）
                        modal.style =“位置：绝对；可见性：隐藏；宽度：500px；高度：” +
                            “ 620px；填充：0px；边距：0px；边框：1px #ddd实心；背景：白色；”
                        modal.innerHTML ='<iframe id =“ qq_login_iframe” frameborder =“ 0” width =“ 100％” height =“ 100％”> </ iframe>'
                        modal.style.top = 0
                        modal.style.left =（（window.innerWidth / 2）-250）+“ px”
                        document.body.appendChild（modal）

                        btn.firstChild.onclick = function（）{
                            var iframe = document.getElementById（'qq_login_iframe'）
                            如果（！iframe.src）{
                                var url =“ https://graph.qq.com/oauth2.0/authorize”
                                var params =“？”

                                params + =“ response_type = token＆” //获取回传access_token
                                params + =“ client_id =” + appid +“＆” //应用的appid
                                params + =“ redirect_uri =” + opts.redirectURI //登录成功后转移的代理页面

                                iframe.src =网址+参数
                            }
                            modal.style.visibility ='可见'
                        }
                    }
                }其他{
                    抛出新错误（'未找到插入例程：'）
                }
            }
        }

        _insertButton.TEMPLATE = ['<a href =“ javascript :;” onclick =“ {onclick};”> <img src =“ {src}” alt =“ {alt}” border =“ 0” /> </a>'] .join（''）;
        _insertButton.getBtnHtml =函数（parasOpts，btnMode，opts）{
            返回arguments.callee.MODE [btnMode] && arguments.callee.MODE [btnMode]（parasOpts，opts）;
        };
        _insertButton.getBtnHtml.MODE = {
            “标准”：功能（parasObj）{
                var windowId = ~~ $ Cookie.get（“ __ qc_wId”）+ 10000;
                var baseStr = $ Toolkit.format（_insertButton.TEMPLATE，{
                    src：'https：//'+ resDomain +'/ qzone / vas / opensns / res / img / Connect_logo_'+ parasObj.size +'.png'，
                    onclick：parasObj.fullWindow吗？'返回window.open（\''+ parasObj.url +'\'，\'oauth2Login_'+ windowId +'\'）;' ：'返回window.open（\''+ parasObj.url +'\'，\'oauth2Login_'+ windowId +'\'，\'height = 525，width = 585，工具栏=否，菜单栏=否，滚动条=否，状态=否，位置=是，可调整大小=是\'）'，
                    alt：“ QQ登录”
                }）;
                返回baseStr;
            }，“ showUserAfterLogin”：函数（parasObj，opts）{
                var baseStr = $ JSON.stringify（opts），sizeObj = BUTTON_STYLE [opts ['size']] || BUTTON_STYLE ['B_M']，
                    size = sizeObj ['size']。split（“ *”），
                    outsideStr ='<iframe frameBorder =“ 0” scrolling =“ no” src =“ https：//'+ mainDomain +'/qzone/openapi/frames/login_button.html#para='+ encodeURIComponent（baseStr）+'”宽度=“'+ Math.max（200，size [0]）+'” height =“'+ size [1] +'” allowTransparency =“ true”> </ iframe>';
                返回externalStr;
            }
        };
        _insertButton._getPopupUrl =函数（优化）{
            var scope = opts ['scope'] || 'all'，redirectURI = opts ['redirectURI'] || ''，
                display = opts ['display'] || ”，clientId = opts ['appId'] || QC.getAppId（）;
            redirectURI = redirectURI || （'http％3A％2F％2Fqzonestyle.gtimg.cn％2Fqzone％2Fopenapi％2Fredirect-1.0.1.html'）|| （location.protocol +“ //” + location.host +（（location.port && location.port！=“ 80”）？（“：” + location.port）：“”）+“ /qc_callback.html” ）|| “”;
            如果（ieVer <= 6）{
                redirectURI ='https://graph.qq.com/jsdkproxy/redirect_ie6.html#'+ encodeURIComponent（redirectURI）;
            }
            var paras = ['client_id ='+ clientId，'response_type = token']，
                url ='https://graph.qq.com/oauth2.0/authorize';
            如果（范围）{
                paras.push（'scope ='+ scope）;
            }
            如果（redirectURI）{
                如果（redirectURI.indexOf（'：//'）> 0）{
                    redirectURI = encodeURIComponent（redirectURI）;
                }
                paras.push（'redirect_uri ='+ redirectURI）;
            }
            if（display =='mobile'）{
                paras.push（'display ='+ display）;
            }
            url = url +“？” + paras.join（“＆”）;
            返回网址
        };
        var _getACToken = function（）{
            返回access_token || 函数（）{
                var matcher = location && location.hash.match（/ access_token =（[^＆] *）/ i），_timer，_cbPool = []，_keys;
                var __qc__k;
                如果（（__qc__k = $ Cookie.get（“ __ qc__k”）））{
                    _keys = __qc__k.split（“ =”）;
                    如果（__qc__k.length && _keys.length！= 2）{
                        抛出新的错误（“ QQConnect-> cookie：__ qc__k格式非法”）；
                    }
                }
                access_token =（匹配器&&匹配器[1]）|| （_keys && _keys [1]）;
            }（）;
        };
        var _getMe = function（）{
            var _timer，_cbPool = [];
            _getACToken（）;
            var _fireCallBack =函数（openId，accessToken，_dt）{
                var _crtReq;
                而（_crtReq = _cbPool.shift（））{
                    setTimeout（function（_rq）{
                        返回函数（）{
                            _rq（openId，accessToken，_dt）;
                        }
                    }（_ crtReq））;
                }
            };
            var _getMeError =函数（error_description）{
                $ Console.error（error_description +“：_getMeError”）;
                window.callback（{error_description：error_description}）;
            };
            var脚本，fn；
            var getOpenId =函数（_cb）{
                ！fn &&（fn = window.callback）;
                _cb && getOpenId.cbPool.push（_cb）;
                window.callback =函数（_dt）{
                    clearTimeout（_timer）;
                    如果（！_dt.openid）{
                        返回;
                    }
                    dt_cache = _dt;
                    var openId = _openId = _dt.openid;
                    var aToken = access_token;
                    $ Console.log（“ getMe => openId＆accessToken” + [openId，aToken，script？'通过我接口'：'通过本地']）;
                    var cCb;
                    而（cCb = getOpenId.cbPool.shift（））{
                        cCb（openId，access_token，_dt）;
                    }
                    脚本= null;
                    window.callback = fn;
                };
                如果（！_getACToken（））{
                    _getMeError（“ access_token丢失”）;
                    返回;
                }
                如果（dt_cache）{
                    window.callback（dt_cache）;
                }其他{
                    如果（脚本）返回；
                    脚本= document.createElement（“脚本”）;
                    script.type =“ text / javascript”;
                    script.src =“ https://graph.qq.com/oauth2.0/me?access_token=” + access_token;
                    script.onerror = function（）{
                        _getMeError（“ me接口返回格式错误”）;
                    };
                    var _head = document.getElementsByTagName（“ head”）[0];
                    _head && _head.appendChild（script）;
                    _timer = setTimeout（function（）{
                        _getMeError（“ me接口超时”）;
                    }，5000）；
                }
            };
            getOpenId.cbPool = [];
            返回函数（_cb，_isInitFn）{
                _isInitFn？_cbPool.unshift（_cb）：_cbPool.push（_cb）;
                getOpenId（_fireCallBack）;
                QC.valueStat（350371，1，0）;
            }
        }（）;
        var _signOut = function（）{
            dt_cache = null;
            access_token =未定义;
            _user_info = null;
            var logoutFun;
            for（var i = 0; i <_logoutFuns.length; i ++）{
                logoutFun = _logoutFuns [i];
                logoutFun（）;
            }
            QC.valueStat（350370，1，0）;
        };
        var _showPopup =函数（优化）{
            var url = _insertButton._getPopupUrl（opts || {}）;
            QC.valueStat（350369，1，0）;
            返回window.open（url）;
        };
        var _DEF_LOGIN_FUN =函数（dt，opts）{
            QC.Login.fillUserInfo（opts ['btnId']，dt）;
        };
        var _loginFuns = []，_logoutFuns = []，_user_info;
        //初始化JSSDK函数
        var retFun =函数（opts，loginFun，logoutFun，__ outCallFlag）{
            var args = arguments;
            var result = null;
            //允许在登录初始化时设定access_token 2018-8-16 zhiyonglao
            access_token = access_token || opts.access_token;
            //添加登出变量
            ！__ outCallFlag && logoutFun！== null && _logoutFuns.push（function（__opts）{
                返回函数（）{
                    var argPara = [args [0]，null，null，1]；
                    （logoutFun || EMPTY_FUN）（__ opts）;
                    //修改一下登出逻辑2018-8-16 zhiyonglao
                    _insertButton（__ opts）;
                    // args.callee.apply（null，argPara）;
                }
            }（选择））；
            var _loginFun;
            var loginFunFire = function（）{
                for（var i = 0; i <_loginFuns.length; i ++）{
                    _loginFun = _loginFuns [i];
                    _loginFun（_user_info）;
                }
            };
            ！__ outCallFlag && loginFun！== null && _loginFuns.push（function（__opts）{
                返回函数（dt）{
                    （loginFun || _DEF_LOGIN_FUN）（dt，__opts）;
                }
            }（选择））；
            如果（！_user_info）{
                access_token？_getMe（function（openId）{
                    如果（openId）{
                        QC.api（“ get_user_info”）。success（function（req）{
                            _user_info = req.data;
                            loginFunFire（）;
                        }）。error（function（req）{
                            QC.Console.error（“登录=> getMe获取数据失败” + req）;
                        }）;
                    }其他{
                        _insertButton（opts）;
                    }
                }）：_insertButton（opts）;
            }其他{
                _user_info && loginFunFire（）;
            }
            QC.valueStat（350368，1，0）;

            返回结果；
        };
        $ Object.extend（retFun，{
            insertButton：_insertButton，getMe：_getMe，showPopup：_showPopup，signOut：function（）{
                _openId =“”;
                document.cookie = [“ __qc__k =”，“ path = /;”]。join（“;”）;
                _登出（）;
            }，_ getTokenKeys：函数（）{
                返回{openid：_openId，accessToken：access_token}
            }，检查：function（）{
                QC.valueStat（350372，1，0）;
                返回!! access_token;
            }，_check：function（）{
                返回!!（dt_cache && access_token && _user_info）;
            }，_ onLoginBack：函数（openId，aToken，notRefreshBtn）{
                如果（openId && aToken）{
                    _openId = openId;
                    document.cookie = ['__qc__k ='+ [“ TC_MK”，aToken] .join（“ =”），'path = /']。join（“;”）;
                }
                dt_cache = {client_id：dt_cache && dt_cache.client_id || -1，openid：_openId}；
                _getACToken（）;
                QC.Event.domReady（function（）{
                    QC.init（）;
                    ！notRefreshBtn && QC.Login（{}，null，null，1）;
                }）;
            }，重置：function（）{
                _loginFuns = [];
                _logoutFuns = [];
            }，fillUserInfo：函数（btnId，reqData）{
                var dom = $（btnId），
                    _logoutTemplate = ['<span class =“ qc_item图”> <img src =“ {figureurl}” class =“ {size_key}” /> </ span>'，'<span class =“ qc_item昵称” style =“ margin -left：6px;“> {昵称} </ span>”，“ <span class =” qc_item注销”> <a href =“ javascript：QC.Login.signOut（）;” style =“ margin-left：6px;”>退出</a> </ span>']。join（“”）;
                dom &&（dom.innerHTML = QC.String.format（_logoutTemplate，{
                    昵称：QC.String.escHTML（reqData.nickname），
                    FigureURL：reqData.figureurl
                }））;
            }
        }）;
        返回retFun;
    };
    _qc.Login = Login（）;
    var appId = -1，tmpCfg = null，redirectURI =“”;
    _qc.init =函数（cfg）{
        cfg = cfg || tmpCfg || {};
        tmpCfg = cfg;
        var TKObj = _qc.Login._getTokenKeys（）;
        appId = cfg.appId;
        redirectURI = cfg.redirectURI;
        如果（！TKObj.openid）{
            Proxy.invoke（）;
            如果（fun_ready_pool.length && cfg.appId> -1）{
                for（var i = 0; i <fun_ready_pool.length; i ++）{
                    fun_ready_pool [i]（）;
                }
            }
            返回;
        }
        _qc.Login.getMe（function（oid，token，dt）{
            如果（！~~ dt.error &&（dt.client_id <= 0 || dt.client_id％1000000 == cfg.appId％1000000））{
                appId = dt.client_id = cfg.appId || cfg.clientId || cfg.app_id || cfg.client_id || -1;
                _qc.api._ready && _qc.api._ready（）;
            }其他{
                _qc.Console.error（dt.error_description ||“ appId / client_id不匹配”）;
            }
        }，是对的）；
    };
    _qc.getAppId =函数（ars）{
        如果（ars）{
            fun_ready_pool.push（function（）{
                ars.callee.apply（null，ars）;
            }）;
        }
        返回appId;
    };
    _qc.invoke =函数（）{
        var pxy = Proxy.generateProxy（'FLAProxy'）;
        pxy.invoke（参数）;
    };
    var getAPIConfig = function（）{
        var API_DICT = {
            “ get_user_info”：{
                api：“ https://graph.qq.com/user/get_user_info”，
                方法：“获取”，
                statId：350373
            }，
            “ add_topic”：{api：“ https://graph.qq.com/shuoshuo/add_topic”，方法：“ post”，statId：350374}，
            “ add_one_blog”：{api：“ https://graph.qq.com/blog/add_one_blog”，方法：“ post”，statId：350375}，
            “ add_album”：{api：“ https://graph.qq.com/photo/add_album”，方法：“ post”，statId：350376}，
            “ upload_pic”：{api：“ https://graph.qq.com/photo/upload_pic”，方法：“ post”，statId：350377}，
            “ list_album”：{api：“ https://graph.qq.com/photo/list_album”，方法：“ get”，statId：350391}，
            “ add_share”：{api：“ https://graph.qq.com/share/add_share”，方法：“ post”，statId：350378}，
            “ check_page_fans”：{api：“ https://graph.qq.com/user/check_page_fans”，方法：“ get”，statId：350379}，
            “ add_t”：{api：“ https://graph.qq.com/t/add_t”，方法：“ post”，statId：350380}，
            “ add_pic_t”：{api：“ https://graph.qq.com/t/add_pic_t”，方法：“ post”，statId：350381}，
            “ del_t”：{api：“ https://graph.qq.com/t/del_t”，方法：“ post”，statId：350382}，
            “ get_repost_list”：{api：“ https://graph.qq.com/t/get_repost_list”，方法：“ get”，statId：350383}，
            “ get_info”：{api：“ https://graph.qq.com/user/get_info”，方法：“ get”，statId：350384}，
            “ get_other_info”：{api：“ https://graph.qq.com/user/get_other_info”，方法：“ get”，statId：350385}，
            “ get_fanslist”：{api：“ https://graph.qq.com/relation/get_fanslist”，方法：“ get”，statId：350386}，
            “ get_idollist”：{api：“ https://graph.qq.com/relation/get_idollist”，方法：“ get”，statId：350387}，
            “ add_idol”：{api：“ https://graph.qq.com/relation/add_idol”，方法：“ post”，statId：350388}，
            “ del_idol”：{api：“ https://graph.qq.com/relation/del_idol”，方法：“ post”，statId：350389}，
            “ get_tenpay_addr”：{api：“ https://graph.qq.com/cft_info/get_tenpay_addr”，方法：“ get”，statId：350390}
        };
        返回函数（apiKey）{
            返回API_DICT [apiKey] || {};
        }
    }（）;
    （函数（）{
        var aid = getDataPara（“ appid”）;
        var rUri = getDataPara（“ redirecturi”）;
        如果（援助）{
            _qc.Console.info（“检测到自动初始化参数\ nappId：” +辅助+“ \ nrUri：” + rUri）;
            如果（isNaN（aid））{
                _qc.Console.error（“参数appid错误”）;
            } else if（rUri && rUri.indexOf（“ http”）！= 0）{
                _qc.Console.error（“参数rediectURI错误”）;
            }其他{
                _qc.Event.domReady（function（）{
                    _qc.init（{appId：aid，redirectURI：rUri}）;
                }）;
            }
        }
        var callback = getDataPara（“ callback”）;
        如果（回调）{
            window._b_is_qc_cb_win = true;
            QC.Login.getMe（function（openId，accessToken，backData）{
                如果（window.opener）{
                    QC.Console.info（“ cb_method_1：window.opener.QC.Login._onLoginBack”）;
                    尝试{
                        window.opener.QC.Login._onLoginBack（openId，accessToken）;
                    }抓住（e）{
                        QC.Console.info（“ cb_method_2：window.opener.postMessage”）;
                        尝试{
                            window.opener.postMessage（“ invoke @@@ QC.Login._onLoginBack＃” + [openId，accessToken] .join（“，”），“ *”）;
                        }抓住（e1）{
                            QC.Console.info（“ cb_method_3：QC.invoke”）;
                            尝试{
                                QC.invoke（“ QC.Login._onLoginBack”，openId，accessToken）;
                            }抓住（e2）{
                                QC.Console.info（“ cb_method_5：[空]”）;
                            }
                        }
                    }
                }其他{
                    QC.Console.info（“ cb_method_4：QC.invoke”）;
                    尝试{
                        QC.invoke（“ QC.Login._onLoginBack”，openId，accessToken）;
                    }抓住（e3）{
                    }
                }
                setTimeout（function（）{
                    如果（ieVer> 7）{
                        var wnd = window.open（'about：blank'，'_self'）;
                        wnd.close（）;
                    }其他{
                        window.close（）;
                    }
                }，1000）；
            }）;
            QC.pv（“ graph.qq.com”，“ / open / connect / channel / pv”）;
        } else if（aid && QC.Login.check（））{
            QC.Event.domReady（function（）{
                QC.Login.getMe（function（openId，accessToken）{
                    QC.Login._onLoginBack（openId，accessToken，1）;
                }）;
            }）;
            QC.pv（“ graph.qq.com”，“ / open / connect / logged_in / pv”）;
            QC.reportBNL（11236，aid）;
        }其他{
            QC.pv（“ graph.qq.com”，“ / open / connect / pv”）;
            QC.reportBNL（11236，aid）;
        }
    }）（）;
}）（质量控制）；
（函数（）{
    window.qc = QC;
    如果（typeof Object.freeze ==“ function”）{
        Object.freeze（QC）;
    }
}）（）;
/ * | xGv00 | 5801e8c14125189263c22cf1b2f9e2d8 * /